/**
 * ECS 实体使用示例
 * 
 * 展示了如何正确地创建、使用和销毁实体
 */

import { ecs } from "../../../../core/ecs/ECS";
import { Player } from "./player";

/**
 * 基础使用示例
 */
export class BasicEntityUsage {
    /**
     * 示例 1：创建和使用实体
     */
    static example1_CreateEntity(): void {
        console.log('=== 示例 1：创建实体 ===');
        
        // 使用 ecs.getEntity() 创建或从对象池获取实体
        // 会自动调用 init() 方法
        const player = ecs.getEntity(Player);
        
        console.log('玩家实体 ID:', player.eid);
        console.log('玩家名称:', player.name);
        console.log('玩家血量:', player.currentHealth);
        
        // 使用实体方法
        player.setPosition(100, 200);
        player.addScore(50);
    }
    
    /**
     * 示例 2：修改实体状态
     */
    static example2_ModifyEntity(): void {
        console.log('\n=== 示例 2：修改实体状态 ===');
        
        const player = ecs.getEntity(Player);
        
        // 修改组件
        player.RenderComponent.visible = true;
        player.RenderComponent.alpha = 0.8;
        
        // 调用业务方法
        player.takeDamage(30);
        console.log('剩余血量:', player.currentHealth);
        
        player.heal(20);
        console.log('治疗后血量:', player.currentHealth);
        
        player.levelUp();
        console.log('当前等级:', player.level);
    }
    
    /**
     * 示例 3：销毁实体（回收到对象池）
     */
    static example3_DestroyEntity(): void {
        console.log('\n=== 示例 3：销毁实体 ===');
        
        const player = ecs.getEntity(Player);
        player.currentHealth = 50;
        player.level = 5;
        
        console.log('销毁前 - 血量:', player.currentHealth, '等级:', player.level);
        
        // 销毁实体（实际上是回收到对象池）
        player.destroy();
        
        // 再次创建，会从对象池获取并调用 init() 重置状态
        const newPlayer = ecs.getEntity(Player);
        console.log('重新创建后 - 血量:', newPlayer.currentHealth, '等级:', newPlayer.level);
        console.log('状态已重置！');
    }
    
    /**
     * 示例 4：批量创建实体
     */
    static example4_BatchCreate(): void {
        console.log('\n=== 示例 4：批量创建实体 ===');
        
        const players: Player[] = [];
        
        for (let i = 0; i < 5; i++) {
            const player = ecs.getEntity(Player);
            player.setPosition(i * 100, 100);
            player.level = i + 1;
            players.push(player);
        }
        
        console.log(`创建了 ${players.length} 个玩家实体`);
        players.forEach((p, index) => {
            console.log(`玩家 ${index}: ID=${p.eid}, Level=${p.level}`);
        });
    }
    
    /**
     * 示例 5：实体的生命周期
     */
    static example5_EntityLifecycle(): void {
        console.log('\n=== 示例 5：实体生命周期 ===');
        
        // 1. 创建（调用 init()）
        console.log('1. 创建实体...');
        const player = ecs.getEntity(Player);
        console.log('   实体已创建, ID:', player.eid);
        
        // 2. 使用
        console.log('2. 使用实体...');
        player.addScore(100);
        player.levelUp();
        
        // 3. 销毁（回收到对象池）
        console.log('3. 销毁实体...');
        const oldEid = player.eid;
        player.destroy();
        console.log('   实体已销毁, isValid:', player.isValid);
        
        // 4. 复用（从对象池获取，再次调用 init()）
        console.log('4. 复用实体...');
        const reusedPlayer = ecs.getEntity(Player);
        console.log('   复用的实体 ID:', reusedPlayer.eid);
        console.log('   是否是同一个对象?', reusedPlayer.eid === oldEid);
        console.log('   状态已重置: score=', reusedPlayer.score);
    }
}

/**
 * 高级使用示例
 */
export class AdvancedEntityUsage {
    /**
     * 示例 6：带配置创建实体
     */
    static example6_EntityWithConfig(): void {
        console.log('\n=== 示例 6：带配置创建实体 ===');
        
        // 创建实体工厂函数
        function createPlayerWithConfig(config: {
            x: number;
            y: number;
            level: number;
            health: number;
        }): Player {
            const player = ecs.getEntity(Player);
            player.setPosition(config.x, config.y);
            player.level = config.level;
            player.currentHealth = config.health;
            player.maxHealth = config.health;
            return player;
        }
        
        // 使用配置创建
        const warrior = createPlayerWithConfig({
            x: 100,
            y: 200,
            level: 10,
            health: 150,
        });
        
        console.log('战士:', {
            level: warrior.level,
            health: warrior.currentHealth,
        });
    }
    
    /**
     * 示例 7：实体对象池性能测试
     */
    static example7_PoolPerformance(): void {
        console.log('\n=== 示例 7：对象池性能测试 ===');
        
        // 测试创建性能
        console.log('创建 1000 个实体...');
        const startCreate = performance.now();
        
        for (let i = 0; i < 1000; i++) {
            const player = ecs.getEntity(Player);
            player.destroy();
        }
        
        const createTime = performance.now() - startCreate;
        console.log(`耗时: ${createTime.toFixed(2)}ms`);
        
        // 测试复用性能
        console.log('\n从对象池复用 1000 个实体...');
        const startReuse = performance.now();
        
        for (let i = 0; i < 1000; i++) {
            const player = ecs.getEntity(Player);
            player.destroy();
        }
        
        const reuseTime = performance.now() - startReuse;
        console.log(`耗时: ${reuseTime.toFixed(2)}ms`);
        console.log(`性能提升: ${(createTime / reuseTime).toFixed(2)}x`);
    }
    
    /**
     * 示例 8：查询实体
     */
    static example8_QueryEntities(): void {
        console.log('\n=== 示例 8：查询实体 ===');
        
        // 创建多个实体
        for (let i = 0; i < 5; i++) {
            const player = ecs.getEntity(Player);
            player.level = i + 1;
        }
        
        // 获取当前活动的实体数量
        const count = ecs.activeEntityCount();
        console.log(`当前活动实体数量: ${count}`);
        
        // 通过 EID 查询实体
        const entity = ecs.getEntityByEid(1);
        if (entity) {
            console.log('找到实体:', entity.name, 'EID:', entity.eid);
        }
    }
}

/**
 * 错误示例（不要这样做）
 */
export class WrongEntityUsage {
    /**
     * ❌ 错误示例 1：在构造函数中添加组件
     */
    static wrongExample1_AddComponentInConstructor(): void {
        console.log('\n=== ❌ 错误示例 1 ===');
        
        // @ecs.register('WrongEntity')
        // class WrongEntity extends ecs.Entity {
        //     constructor() {
        //         super();
        //         this.add(RenderComponent);  // ❌ 错误！
        //     }
        //     init(): void { }
        // }
        
        console.log('❌ 不要在构造函数中添加组件！');
        console.log('✅ 应该在 init() 方法中添加组件');
    }
    
    /**
     * ❌ 错误示例 2：忘记实现 init() 方法
     */
    static wrongExample2_NoInitMethod(): void {
        console.log('\n=== ❌ 错误示例 2 ===');
        
        // @ecs.register('WrongEntity')
        // class WrongEntity extends ecs.Entity {
        //     // ❌ 缺少 init() 方法
        // }
        
        console.log('❌ 实体必须实现 init() 方法！');
        console.log('否则会报错: "实体缺少 init 方法初始化默认组件"');
    }
    
    /**
     * ❌ 错误示例 3：忘记重置状态
     */
    static wrongExample3_ForgetReset(): void {
        console.log('\n=== ❌ 错误示例 3 ===');
        
        // @ecs.register('WrongEntity')
        // class WrongEntity extends ecs.Entity {
        //     public score: number = 0;
        //     
        //     init(): void {
        //         this.add(RenderComponent);
        //         // ❌ 忘记重置 score，会导致对象池复用时状态残留
        //     }
        // }
        
        console.log('❌ init() 方法中必须重置所有状态！');
        console.log('否则对象池复用时会出现状态残留');
    }
    
    /**
     * ❌ 错误示例 4：直接 new 实体
     */
    static wrongExample4_DirectNew(): void {
        console.log('\n=== ❌ 错误示例 4 ===');
        
        // const player = new Player();  // ❌ 错误！
        
        console.log('❌ 不要直接 new 实体！');
        console.log('✅ 应该使用 ecs.getEntity(Player)');
    }
}

/**
 * 运行所有示例
 */
export function runAllExamples(): void {
    console.log('╔════════════════════════════════════════╗');
    console.log('║   ECS 实体使用示例                      ║');
    console.log('╚════════════════════════════════════════╝');
    
    // 基础示例
    BasicEntityUsage.example1_CreateEntity();
    BasicEntityUsage.example2_ModifyEntity();
    BasicEntityUsage.example3_DestroyEntity();
    BasicEntityUsage.example4_BatchCreate();
    BasicEntityUsage.example5_EntityLifecycle();
    
    // 高级示例
    AdvancedEntityUsage.example6_EntityWithConfig();
    AdvancedEntityUsage.example7_PoolPerformance();
    AdvancedEntityUsage.example8_QueryEntities();
    
    // 错误示例
    WrongEntityUsage.wrongExample1_AddComponentInConstructor();
    WrongEntityUsage.wrongExample2_NoInitMethod();
    WrongEntityUsage.wrongExample3_ForgetReset();
    WrongEntityUsage.wrongExample4_DirectNew();
    
    console.log('\n✅ 所有示例运行完成！');
}

